package analysisAndCode;

import entity.Word;
import utils.WordUtil;

import java.util.List;

public class Parser1 {

    // 单词列表
    private List<Word> wordList;

    // 当前指向单词
    private Word token;

    // 下一个单词下标
    private int index;

    // 语法分析树 缩进
    private int treeIndex;

    // 语法分析树
    private String syntaxTree;

    // 语法错误
    private String syntaxError;

    // 程序入口 A
    public void parser(){
        token = getNextToken();
        syntaxTree("程序开始");
        treeIndex++;
        syntaxTree("声明语句");
        treeIndex++;
        while (!(token.getWord().equals("int") && wordList.get(index).getWord().equals("main"))){
            index--;
            declarationStatement();
            token = getNextToken();
            if(!(token.getWord().equals("int") && wordList.get(index).getWord().equals("main"))){
                token = getNextToken();
            }
        }
        treeIndex--;
        syntaxTree("main()函数");
        treeIndex++;
        token = getNextToken();
        token = getNextToken();
        if(!token.getWord().equals("(")){
            SyntaxError("main函数缺少左括号");
            index--;
        }
        token = getNextToken();
        if(!token.getWord().equals(")")){
            SyntaxError("main函数缺少右括号");
            index--;
        }
        syntaxTree("复合语句");
        treeIndex++;
        // 复合语句
        compoundSentenceAnalyzer();
        treeIndex--;
        treeIndex--;

        if(index == wordList.size()){
            return;
        }
        syntaxTree("函数块");
        treeIndex++;
        // 函数块
        functionBlock();
        treeIndex--;
//        token = getNextToken();
//        while (token.getWord().equals("int") || token.getWord().equals("char") || token.getWord().equals("float") || token.getWord().equals("void")){
//            FunctionDefinitionAnalyzer();
//            token = getNextToken();
//        }
    }

    // 函数块 D
    private void functionBlock() {
        syntaxTree("函数定义");
        treeIndex++;
        // 函数定义
        functionDefinition();
        treeIndex--;
        if(index != wordList.size()){
            // 继续匹配函数
            functionBlock();
        }
    }

    // 函数定义 H
    private void functionDefinition() {
        token = getNextToken();
        // 匹配函数类型
        if(token.getWord().equals("int") ||
                token.getWord().equals("char") ||
                token.getWord().equals("float") ||
                token.getWord().equals("void")){
            token = getNextToken();
            // 匹配函数名
            if(!WordUtil.isIdentifier(token)){
                SyntaxError("函数缺少函数名");
            }
            token = getNextToken();
            // 匹配左括号
            if(!token.getWord().equals("(")){
                SyntaxError("函数定义缺少左括号");
            }
            token = getNextToken();
            // 查看是否有形参
            if(!token.getWord().equals(")")){
                // 函数定义形参列表
                functionDefinitionFormalParametersList();
                if(!token.getWord().equals(")")){
                    SyntaxError("函数定义形参列表缺少右括号");
                }
            }
            syntaxTree("复合语句");
            treeIndex++;
            // 复合语句
            compoundSentenceAnalyzer();
            treeIndex--;
        }else {
            SyntaxError("函数定义类型错误");
        }
    }

    // 函数定义形参列表 P
    private void functionDefinitionFormalParametersList() {
        // 函数定义形参
        functionDefinitionFormalParameters();
    }

    // 函数定义形参 V
    private void functionDefinitionFormalParameters() {
        if (token.getWord().equals("int") || token.getWord().equals("char") || token.getWord().equals("float")){
            token = getNextToken();
            // 匹配标识符
            if(!WordUtil.isIdentifier(token)){
                SyntaxError("形参列表形参不是标识符");
            }
            token = getNextToken();
            // 是否还有形参
            if(token.getWord().equals(",")){
                token = getNextToken();
                functionDefinitionFormalParameters();
            }
        }else{
            SyntaxError("函数声明形参类型错误");
        }
    }

    // 声明语句 B
    private void declarationStatement(){
        token = getNextToken();
        if (token.getWord().equals("const")){
            syntaxTree("常量声明语句");
            treeIndex++;
            // 处理常量声明
            constDeclareAnalyzer();
            treeIndex--;
        } else if (token.getWord().equals("int") || token.getWord().equals("char") || token.getWord().equals("float") || token.getWord().equals("void")) {
            token = getNextToken();
            if(!WordUtil.isIdentifier(token)){
                SyntaxError("函数声明或变量声明错误");
                nextLine();
                return;
            }
            token = getNextToken();
            if(token.getWord().equals("(")){
                syntaxTree("函数声明语句");
                treeIndex++;
                // 处理函数声明
                functionDeclareAnalyzer();
                treeIndex--;
            } else if (token.getWord().equals("=") || token.getWord().equals(",") || token.getWord().equals(";")) {
                syntaxTree("变量声明语句");
                treeIndex++;
                // 处理变量声明
                if (token.getWord().equals("=")){
                    // 匹配表达式
                    expression();
                    token = getNextToken();
                    if (token.getWord().equals(",")) {
                        // 变量声明表
                        variableDeclareAnalyzer();
                    }
                }else if (token.getWord().equals(",")){
                    // 继续匹配变量声明
                    variableDeclareAnalyzer();
                }
                treeIndex--;
            }else {
                SyntaxError("既不是函数声明，也不是变量声明");
                nextLine();
                return;
            }
        } else {
            SyntaxError("既不是函数声明，也不是变量声明，也不是常量声明");
            nextLine();
            return;
        }
        index--;
    }

    // 复合语句 C
    private void compoundSentenceAnalyzer() {
        token = getNextToken();
        // 匹配{
        if(!token.getWord().equals("{")){
            SyntaxError("复合语句缺少{");
        }
        token = getNextToken();
        // 查看复合语句是空
        if(!token.getWord().equals("}")){
            // 语句表
            index--;
            statementList();
        }
        token = getNextToken();
        if(!token.getWord().equals("}")){
            SyntaxError("复合语句缺少}");
        }
    }

    // 语句表 G
    private void statementList() {
        statement();
        token = getNextToken();
        // 是否还有语句
        if(!token.getWord().equals("}")){
            // 匹配下一条语句
            index--;
            statementList();
        }else {
            index--;
        }
    }

    // 语句 O
    private void statement() {
        token = getNextToken();
        if (token.getWord().equals("int") ||
                token.getWord().equals("char") ||
                token.getWord().equals("float")) {
            index--;
            // 声明语句
            declarationStatement();
        }else if (token.getWord().equals("if") ||
                token.getWord().equals("for") ||
                token.getWord().equals("while") ||
                token.getWord().equals("do") ||
                token.getWord().equals("return")) {
            index--;
            // 控制语句
            controlStatement();
        }else{
            index--;
            // 执行语句
            executeStatement();
        }
    }

    // 控制语句 X
    private void controlStatement() {
        token = getNextToken();
        if (token.getWord().equals("if")){
            index--;
            syntaxTree("if语句");
            treeIndex++;
            // if语句
            ifStatement();
            treeIndex--;
        }else if (token.getWord().equals("for")){
            index--;
            syntaxTree("for语句");
            treeIndex++;
            // for语句
            forStatement();
            treeIndex--;
        }else if (token.getWord().equals("while")){
            index--;
            syntaxTree("while语句");
            treeIndex++;
            // while语句
            whileStatement();
            treeIndex--;
        }else if (token.getWord().equals("do")){
            index--;
            syntaxTree("do while语句");
            treeIndex++;
            // do while语句
            doWhileStatement();
            treeIndex--;
        }else if (token.getWord().equals("return")){
            index--;
            syntaxTree("return语句");
            treeIndex++;
            // return语句
            returnStatement();
            treeIndex--;
        }
    }

    // do while语句 d
    private void doWhileStatement() {
        token = getNextToken();
        if(!token.getWord().equals("do")){
            SyntaxError("do while语句不以do开始");
        }
        syntaxTree("循环用复合语句");
        treeIndex++;
        // 匹配循环用复合语句
        recurrentCompoundStatements();
        treeIndex--;
        token = getNextToken();
        if(!token.getWord().equals("while")){
            SyntaxError("do while语句缺少while");
        }
        token = getNextToken();
        if(!token.getWord().equals("(")){
            SyntaxError("while语句条件缺少左括号");
        }
        syntaxTree("表达式");
        treeIndex++;
        // 匹配while条件
        expression();
        treeIndex--;
        if(!token.getWord().equals(")")){
            SyntaxError("while语句条件缺少右括号");
        }
    }

    // for语句 b
    private void forStatement() {
        token = getNextToken();
        if(!token.getWord().equals("for")){
            SyntaxError("for语句不以for开始");
        }
        token = getNextToken();
        if(!token.getWord().equals("(")){
            SyntaxError("for语句条件缺少左括号");
        }
        syntaxTree("表达式1");
        treeIndex++;
        // 匹配for循环第一个条件
        expression();
        treeIndex--;
        if(!token.getWord().equals(";")){
            SyntaxError("for语句条件缺少;");
        }
        syntaxTree("表达式2");
        treeIndex++;
        // 匹配for循环第二个条件
        expression();
        treeIndex--;
        if(!token.getWord().equals(";")){
            SyntaxError("for语句条件缺少;");
        }
        syntaxTree("表达式3");
        treeIndex++;
        // 匹配for循环第三个条件
        expression();
        treeIndex--;
        if(!token.getWord().equals(")")){
            SyntaxError("for语句条件缺少右括号");
        }
        syntaxTree("循环语句");
        treeIndex++;
        // 匹配循环语句
        loopStatement();
        treeIndex--;
    }

    // 循环语句 j
    private void loopStatement() {
        token = getNextToken();
        if (token.getWord().equals("int") ||
                token.getWord().equals("char") ||
                token.getWord().equals("float")) {
            index--;
            // 声明语句
            declarationStatement();
        }else if (token.getWord().equals("{")) {
            index--;
            // 循环用复合语句
            recurrentCompoundStatements();
        }else if (token.getWord().equals("if") ||
                token.getWord().equals("for") ||
                token.getWord().equals("while") ||
                token.getWord().equals("do") ||
                token.getWord().equals("return") ||
                token.getWord().equals("continue") ||
                token.getWord().equals("break")){
            index--;
            // 循环执行语句
            loopExecutionStatement();
        }else if(WordUtil.isIdentifier(token)){
            token = getNextToken();
            if(token.getWord().equals("=")){
                index -= 2;
                syntaxTree("赋值语句");
                treeIndex++;
                // 数据处理语句 -- 赋值语句
                assignmentStatement();
                treeIndex--;
            }else if(token.getWord().equals("(")){
                index -= 2;
                syntaxTree("函数调用语句");
                treeIndex++;
                // 数据处理语句 -- 函数调用语句
                functionCallStatement();
                index++;
                treeIndex--;
            }else{
                SyntaxError("不是循环语句" + token.getWord() + " " + index);
            }
        }else {
            SyntaxError("不是循环语句" + token.getWord() + " " + index);
        }
    }

    // 循环执行语句 q
    private void loopExecutionStatement() {
        token = getNextToken();
        if (token.getWord().equals("if")){
            index--;
            syntaxTree("循环用if语句");
            treeIndex++;
            // 循环用if语句
            loopWithIfStatement();
            treeIndex--;
        } else if (token.getWord().equals("for")) {
            index--;
            syntaxTree("for语句");
            treeIndex++;
            // for语句
            forStatement();
            treeIndex--;
        } else if (token.getWord().equals("while")) {
            index--;
            syntaxTree("while语句");
            treeIndex++;
            // while语句
            whileStatement();
            treeIndex--;
        }else if (token.getWord().equals("do")) {
            index--;
            syntaxTree("do while语句");
            treeIndex++;
            // do while语句
            doWhileStatement();
            treeIndex--;
        }else if (token.getWord().equals("return")) {
            index--;
            syntaxTree("return语句");
            treeIndex++;
            // return语句
            returnStatement();
            treeIndex--;
        }else if (token.getWord().equals("break")) {
            index--;
            syntaxTree("break语句");
            treeIndex++;
            // break语句
            breakStatement();
            treeIndex--;
        }else if (token.getWord().equals("continue")) {
            index--;
            syntaxTree("continue语句");
            treeIndex++;
            // continue语句
            continueStatement();
            treeIndex--;
        }
    }

    // while语句 c
    private void whileStatement() {
        token = getNextToken();
        if(!token.getWord().equals("while")){
            SyntaxError("while语句不以while开始");
        }
        token = getNextToken();
        if(!token.getWord().equals("(")){
            SyntaxError("while语句条件缺少左括号");
        }
        syntaxTree("表达式");
        treeIndex++;
        // 匹配while条件
        expression();
        treeIndex--;
        if(!token.getWord().equals(")")){
            SyntaxError("while语句条件缺少右括号");
        }
        syntaxTree("循环语句");
        treeIndex++;
        // 循环语句
        loopStatement();
        treeIndex--;
    }

    // break语句 v
    private void breakStatement() {
        token = getNextToken();
        if(!token.getWord().equals("break")){
            SyntaxError("break语句不以break开始");
        }
        token = getNextToken();
        if(!token.getWord().equals(";")){
            SyntaxError("break语句缺少;结束符");
        }
    }

    // continue语句 w
    private void continueStatement() {
        token = getNextToken();
        if(!token.getWord().equals("continue")){
            SyntaxError("continue语句不以continue开始");
        }
        token = getNextToken();
        if(!token.getWord().equals(";")){
            SyntaxError("continue语句缺少;结束符");
        }
    }

    // return语句 e
    private void returnStatement() {
        token = getNextToken();
        if(!token.getWord().equals("return")){
            SyntaxError("return语句不以return开始");
        }
        token = getNextToken();
        // 有返回值
        if(!token.getWord().equals(";")){
            // 匹配返回值 -- 表达式
            expression();
            if(!token.getWord().equals(";")){
                SyntaxError("return语句缺少;结束符");
            }
        }
    }

    // 循环用if语句 n
    private void loopWithIfStatement() {
        token = getNextToken();
        if(!token.getWord().equals("if")){
            SyntaxError("循环用if语句不以if开始");
        }
        token = getNextToken();
        if(!token.getWord().equals("(")){
            SyntaxError("循环用if语句条件缺少左括号");
        }
        syntaxTree("表达式");
        treeIndex++;
        // 匹配if条件
        expression();
        treeIndex--;
        if(!token.getWord().equals(")")){
            SyntaxError("循环用if语句条件缺少右括号");
        }
        syntaxTree("循环语句");
        treeIndex++;
        // 循环语句
        loopStatement();
        treeIndex--;
        token = getNextToken();
        // 是否有else
        if(token.getWord().equals("else")){
            treeIndex--;
            syntaxTree("循环用else语句");
            treeIndex++;
            syntaxTree("循环语句");
            treeIndex++;
            // 循环语句
            loopStatement();
            treeIndex--;
        }else {
            index--;
        }
    }

    // 循环用复合语句 k
    private void recurrentCompoundStatements() {
        token = getNextToken();
        if(!token.getWord().equals("{")){
            SyntaxError("循环用复合语句缺少{");
        }
        // 循环语句表
        loopStatementTable();
        token = getNextToken();
        if(!token.getWord().equals("}")){
            SyntaxError("循环用复合语句缺少} " + token.getWord() + " " + index);
        }
    }

    // 循环语句表 r
    private void loopStatementTable() {
        // 匹配循环语句
        loopStatement();
        token = getNextToken();
        if(token.getWord().equals("}")){
            index--;
        }else {
            index--;
            loopStatement();
        }
    }

    // if语句 a
    private void ifStatement() {
        token = getNextToken();
        if(!token.getWord().equals("if")){
            SyntaxError("if语句不以if开始");
        }
        token = getNextToken();
        if(!token.getWord().equals("(")){
            SyntaxError("if语句条件缺少左括号");
        }
        syntaxTree("表达式");
        treeIndex++;
        // 匹配if条件
        expression();
        treeIndex--;
        if(!token.getWord().equals(")")){
            SyntaxError("if语句条件缺少右括号");
        }
        syntaxTree("语句");
        treeIndex++;
        // 复合语句
        statement();
        treeIndex--;
        index++;
        token = getNextToken();
        // 是否有else
        if(token.getWord().equals("else")){
            treeIndex--;
            syntaxTree("else语句");
            treeIndex++;
            syntaxTree("语句");
            treeIndex++;
            // 复合语句
            statement();
            treeIndex--;
            if (!token.getWord().equals("}")){
                SyntaxError("复合语句缺少}");
            }else {
                index++;
            }
        }else {
            index--;
        }
    }

    // 执行语句 U
    private void executeStatement() {
        token = getNextToken();
        if(token.getWord().equals("{")){
            index--;
            // {复合语句}
            compoundSentenceAnalyzer();
        }else if(WordUtil.isIdentifier(token)){
            token = getNextToken();
            if(token.getWord().equals("=")){
                index -= 2;
                syntaxTree("赋值语句");
                treeIndex++;
                // 数据处理语句 -- 赋值语句
                assignmentStatement();
                treeIndex--;
            }else if(token.getWord().equals("(")){
                index -= 2;
                syntaxTree("函数调用语句");
                treeIndex++;
                // 数据处理语句 -- 函数调用语句
                functionCallStatement();
                index++;
                treeIndex--;
            }else{
                SyntaxError("不是数据处理语句 " + token.getWord() + " " + index);
            }
        }
    }

    // 函数调用语句 Z
    private void functionCallStatement() {
        // 函数调用
        functionCall();
        if(!token.getWord().equals(";")){
            SyntaxError("赋值语句缺少;结束");
        }
    }

    // 赋值语句 Y
    private void assignmentStatement() {
        // 赋值表达式
        assignmentExpression();
        if(!token.getWord().equals(";")){
            SyntaxError("赋值语句缺少;结束");
            System.out.println(token.getWord() + " " + index);
        }
    }

    // 变量声明表 S
    private void variableDeclareAnalyzer() {
        token = getNextToken();
        if(!WordUtil.isIdentifier(token)){
            SyntaxError("变量声明表错误");
            nextLine();
            return;
        }
        token = getNextToken();
        if (token.getWord().equals("=") || token.getWord().equals(",") || token.getWord().equals(";")) {
            // 处理变量声明
            if (token.getWord().equals("=")){
                // 匹配表达式
                expression();
            }else if (token.getWord().equals(",")){
                // 继续匹配变量声明
                variableDeclareAnalyzer();
            }
        }else {
            SyntaxError("变量声明表标识符后期望值错误");
            nextLine();
            return;
        }
    }

    // 表达式 h
    // 判断是 关系、算术、布尔、赋值表达式 哪一个
    private void expression(){
        int i = index;
        token = getNextToken();
        // 如果是标识符
        if(WordUtil.isIdentifier(token)){
            token = getNextToken();
            // 下一个是左括号 -- 函数调用
            if(token.getWord().equals("(")){
                // 算术表达式 -- 项 -- 因子 -- 函数调用
                index -= 2;
                arithmeticExpression();
                token = getNextToken();
                if(token.getWord().equals(">") || token.getWord().equals("<")
                        || token.getWord().equals(">=") || token.getWord().equals("<=")
                        || token.getWord().equals("==") || token.getWord().equals("!=")){
                    index = i;
                    relationalExpression();
                    token = getNextToken();
                    if(token.getWord().equals("&&") || token.getWord().equals("||")){
                        index = i;
                        booleanExpression();
                    }
                }
                if(token.getWord().equals("&&") || token.getWord().equals("||")){
                    index = i;
                    booleanExpression();
                }
            } else if (token.getWord().equals("=")) {
                // 下一个是等号 -- 赋值表达式
                index -= 2;
                assignmentExpression();
            } else {
                // 算数表达式 -- 项 -- 因子 -- 变量
                index -= 2;
                arithmeticExpression();
                token = getNextToken();
                if(token.getWord().equals(">") || token.getWord().equals("<")
                        || token.getWord().equals(">=") || token.getWord().equals("<=")
                        || token.getWord().equals("==") || token.getWord().equals("!=")){
                    index = i;
                    relationalExpression();
                    token = getNextToken();
                    if(token.getWord().equals("&&") || token.getWord().equals("||")){
                        index = i;
                        booleanExpression();
                    }
                }
                if(token.getWord().equals("&&") || token.getWord().equals("||")){
                    index = i;
                    booleanExpression();
                }
            }
        }else if(token.getWord().equals("(")){
            // 如果是左括号，则因子是算术表达式
            index--;
            arithmeticExpression();
            token = getNextToken();
            if(token.getWord().equals(">") || token.getWord().equals("<")
                    || token.getWord().equals(">=") || token.getWord().equals("<=")
                    || token.getWord().equals("==") || token.getWord().equals("!=")){
                index = i;
                relationalExpression();
                token = getNextToken();
                if(token.getWord().equals("&&") || token.getWord().equals("||")){
                    index = i;
                    booleanExpression();
                }
            }
            if(token.getWord().equals("&&") || token.getWord().equals("||")){
                index = i;
                booleanExpression();
            }
        }
        // 算数表达式 -- 项 -- 因子 -- 常量
        if(WordUtil.isIntegerConstant(token) || WordUtil.isRealConstant(token) || WordUtil.isCharacterConstant(token)){
            index--;
            arithmeticExpression();
            token = getNextToken();
            if(token.getWord().equals(">") || token.getWord().equals("<")
                    || token.getWord().equals(">=") || token.getWord().equals("<=")
                    || token.getWord().equals("==") || token.getWord().equals("!=")){
                index = i;
                relationalExpression();
                token = getNextToken();
                if(token.getWord().equals("&&") || token.getWord().equals("||")){
                    index = i;
                    booleanExpression();
                }
            }
            if(token.getWord().equals("&&") || token.getWord().equals("||")){
                index = i;
                booleanExpression();
            }
        }
        // 布尔表达式 -- 非
        if(token.getWord().equals("!")){
            index--;
            booleanExpression();
        }
    }

    // 布尔表达式 p
    private void booleanExpression() {
        // 先匹配一个布尔项
        booleanExpressionPa();
        token = getNextToken();
        if(token.getWord().equals("||")){
            // 匹配下一个布尔表达式
            booleanExpression();
        }else {
            index--;
        }
    }

    // 布尔项 pa
    private void booleanExpressionPa() {
        // 先匹配一个布尔因子
        booleanExpressionPb();
        token = getNextToken();
        if(token.getWord().equals("&&")){
            // 匹配下一个布尔项
            booleanExpressionPa();
        }else {
            index--;
        }
    }

    // 布尔因子 pb
    private void booleanExpressionPb() {
        int i = index;
        token = getNextToken();
        // 布尔表达式 -- 非
        if(token.getWord().equals("!")){
            booleanExpression();
        } else {
            index--;
            // 布尔因子 -- 算术表达式
            arithmeticExpression();
            token = getNextToken();
            if(token.getWord().equals(">") || token.getWord().equals("<")
                    || token.getWord().equals(">=") || token.getWord().equals("<=")
                    || token.getWord().equals("==") || token.getWord().equals("!=")){
                index = i;
                // 布尔因子 -- 关系表达式
                relationalExpression();
            }else{
                index--;
            }
        }
    }


    // 关系表达式 o
    private void relationalExpression() {
        // 匹配第一个算术表达式
        arithmeticExpression();
        // 匹配运算符
        token = getNextToken();
        if(token.getWord().equals(">") || token.getWord().equals("<")
                || token.getWord().equals(">=") || token.getWord().equals("<=")
                || token.getWord().equals("==") || token.getWord().equals("!=")){
            // 匹配第一个算术表达式
            arithmeticExpression();
        }else {
            SyntaxError("关系表达式的关系运算符出错");
        }
    }

    // 赋值表达式 f
    private void assignmentExpression() {
        token = getNextToken();
        // 如果是标识符
        if(WordUtil.isIdentifier(token)){
            token = getNextToken();
            if (token.getWord().equals("=")){
                expression();
            }else {
                SyntaxError("赋值表达式缺少等号");
            }
        }else {
            SyntaxError("赋值表达式第一个不是标识符");
        }
    }

    // 算术表达式 m
    private void arithmeticExpression(){
        // 先匹配一个项
        term();
        // 然后匹配后面的
        token = getNextToken();
        if(token.getWord().equals("+") || token.getWord().equals("-")){
            // 匹配下一个算术表达式
            arithmeticExpression();
        }else {
            index--;
            return;
        }
    }

    // 项 t
    private void term() {
        // 先匹配一个因子
        factor();
        // 然后匹配后面的
        token = getNextToken();
        if(token.getWord().equals("*") || token.getWord().equals("/") || token.getWord().equals("%")){
            // 匹配下一个项
            term();
        }else {
            index--;
            return;
        }
    }

    // 因子 x
    private void factor() {
        token = getNextToken();
        // 如果是标识符
        if(WordUtil.isIdentifier(token)){
            token = getNextToken();
            // 下一个是左括号 -- 函数调用
            if(token.getWord().equals("(")){
                // 函数调用
                functionCall();
                // 匹配右括号
                token = getNextToken();
                if(!token.getWord().equals(")")){
                    SyntaxError("函数调用缺少右括号");
                    index--;
                }
            } else {
                // 是变量
                index--;
                return ;
            }
        }else if(token.getWord().equals("(")){
            // 匹配算术表达式
            arithmeticExpression();
            token = getNextToken();
            // 匹配右括号
            if(!token.getWord().equals(")")){
                SyntaxError("算术表达式因子缺少右括号");
            }
        }else if(WordUtil.isIntegerConstant(token) || WordUtil.isRealConstant(token) || WordUtil.isCharacterConstant(token)){

        }else {
            SyntaxError("不是因子");
        }
    }

    // 函数调用 l
    private void functionCall() {
        token = getNextToken();
        // 如果没有实参
        if (token.getWord().equals(")")){
            index--;
            return;
        }
        index--;
        // 匹配实参
        argument();
    }

    // 实参 s
    private void argument() {
        // 匹配表达式
        expression();
        // 然后匹配后面的
        if(token.getWord().equals(",")){
            // 匹配下一个实参
            argument();
        }else {
            index--;
        }
    }

    // 函数声明 F
    private void functionDeclareAnalyzer() {
        token = getNextToken();
        if(!token.getWord().equals(")")){
            // 没有形参
            syntaxTree("函数声明形参列表");
            treeIndex++;
            // 匹配形参列表
            functionDeclarationFormalParameterList();
            treeIndex--;
            // 匹配右括号
            if(!token.getWord().equals(")")){
                SyntaxError("函数声明缺少右括号");
                index--;
            }
        }
        token = getNextToken();
        if(!token.getWord().equals(";")){
            SyntaxError("函数声明缺少结束分号");
            nextLine();
            return;
        }
    }

    // 函数声明形参列表 N
    private void functionDeclarationFormalParameterList() {
        if (token.getWord().equals("int") || token.getWord().equals("char") || token.getWord().equals("float")){
            token = getNextToken();
            // 匹配标识符
            if(!WordUtil.isIdentifier(token)){
                SyntaxError("形参列表形参不是标识符");
                findNowLineNextBracketOrBraceOrSemicolon();
                return;
            }
            token = getNextToken();
            // 是否还有形参
            if(token.getWord().equals(",")){
                token = getNextToken();
                functionDeclarationFormalParameterList();
            }
        }else{
            SyntaxError("函数声明形参类型错误");
            findNowLineNextBracketOrBraceOrSemicolon();
            return;
        }
    }


    // 常量声明 I
    private void constDeclareAnalyzer() {
        token = getNextToken();
        if (token.getWord().equals("int") || token.getWord().equals("char") || token.getWord().equals("float")){
            syntaxTree("常量声明表");
            treeIndex++;
            constantDeclarationTable();
            treeIndex--;
        } else{
            SyntaxError("常量声明未指定类型");
            nextLine();
            return;
        }
    }

    // 常量声明表 L
    private void constantDeclarationTable(){
        token = getNextToken();
        // 匹配标识符
        if(!WordUtil.isIdentifier(token)){
            SyntaxError("常量声明错误");
            nextLine();
            return;
        }
        token = getNextToken();
        // 匹配 ‘=’
        if(!token.getWord().equals("=")){
            SyntaxError("常量声明缺少等号");
            nextLine();
            return;
        }
        token = getNextToken();
        // 匹配常量值
        if(WordUtil.isIntegerConstant(token) || WordUtil.isRealConstant(token) || WordUtil.isCharacterConstant(token)){
            token = getNextToken();
            // 匹配 ‘;’
            if(!token.getWord().equals(";")){
                // 匹配 ‘,’
                if(token.getWord().equals(",")){
                    syntaxTree("常量声明表");
                    treeIndex++;
                    constantDeclarationTable();
                    treeIndex--;
                } else {
                    SyntaxError("常量声明错误");
                    nextLine();
                    return;
                }
            }
        }else {
            SyntaxError("常量声明赋值不是常量");
            nextLine();
            return;
        }
    }

    private void SyntaxError(String str) {
        System.out.println("ERROR......" + str);
        syntaxError += str + " (ROW: " + token.getLine() + ")\n";
    }

    // 语法树缩进
    private void printIndentation(){
        for (int i = 0; i < treeIndex; i++) {
            syntaxTree += "----";
        }
    }

    // 语法树
    private void syntaxTree(String str){
        printIndentation();
        syntaxTree += str + " (ROW: " + token.getLine() + ")\n";
    }

    // 发现当前行的括号、分号
    private void findNowLineNextBracketOrBraceOrSemicolon(){
        int nowLine = wordList.get(index - 2).getLine();
        if(token.getLine() == nowLine + 1){
            index--;
            return;
        }
        for (int i = index - 1; i < wordList.size(); i++) {
            if(wordList.get(i).getWord().equals(")")){
                index = i;
                nowLine = wordList.get(i).getLine();
                break;
            } else if(wordList.get(i).getWord().equals("}")){
                index = i;
                nowLine = wordList.get(i).getLine();
                break;
            } else if(wordList.get(i).getWord().equals(";")){
                index = i;
                nowLine = wordList.get(i).getLine();
                break;
            }
        }
    }

    // 寻找下一行起始位置
    private void nextLine(){
        int nowLine = token.getLine();
        if (wordList.get(index - 2).getLine() == nowLine - 1){
            index--;
            return;
        }
        for (int i = index; i < wordList.size(); i++) {
            if(wordList.get(i).getLine() == nowLine + 1){
                index = i;
                nowLine = wordList.get(i).getLine();
                break;
            }
        }
        if (nowLine == token.getLine()){
            index = wordList.size();
        }
    }

    public Parser1(List<Word> wordList) {
        this.wordList = wordList;
        this.index = 0;
        this.treeIndex = 0;
        this.syntaxTree = "";
        this.syntaxError = "";
    }

    public List<Word> getWordList() {
        return wordList;
    }

    public void setWordList(List<Word> wordList) {
        this.wordList = wordList;
    }

    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }

    public String getSyntaxTree() {
        return syntaxTree;
    }

    public String getSyntaxError() {
        return syntaxError;
    }

    public void setSyntaxError(String syntaxError) {
        this.syntaxError = syntaxError;
    }

    public void setSyntaxTree(String syntaxTree) {
        this.syntaxTree = syntaxTree;
    }

    public Word getNextToken(){
        if(index < wordList.size() && !wordList.isEmpty()){
            Word word = wordList.get(index);
            index++;
            return word;
        }
        return null;
    }
}

